// 出借人中心页面业务逻辑文件

/**
 * 页面加载完成后执行的初始化函数
 */
function initLenderDashboard() {
    console.log('出借人中心页面初始化完成');
    
    // 首先进行用户令牌认证
    authenticateUserToken();
    
    // 添加退出登录事件监听
    addLogoutEventListener();
    
    // 初始化搜索和过滤功能
    initSearchAndFilterFunctionality();
}

/**
 * 存储原始车辆列表数据
 */
let originalVehicleList = [];

/**
 * 当前选中的过滤状态
 */
let currentFilterStatus = ''; // '' 表示全部车辆

/**
 * 初始化搜索和过滤功能
 */
function initSearchAndFilterFunctionality() {
    const searchInput = document.querySelector('.search-bar .search-input');
    const searchBtn = document.querySelector('.search-bar .search-btn');
    const filterButtons = document.querySelectorAll('.filter-options .filter-btn');
    
    // 初始化搜索功能
    if (searchInput && searchBtn) {
        // 添加搜索按钮点击事件
        searchBtn.addEventListener('click', performSearch);
        
        // 添加输入框回车事件
        searchInput.addEventListener('keypress', function(event) {
            if (event.key === 'Enter') {
                performSearch();
            }
        });
        
        // 使用防抖优化实时搜索体验
        const debouncedSearch = window.SearchUtils ? 
            window.SearchUtils.debounce(performSearch, 300) : null;
        
        // 添加输入事件（实时搜索）
        if (debouncedSearch) {
            searchInput.addEventListener('input', debouncedSearch);
        }
    }
    
    // 初始化过滤按钮功能
    if (filterButtons.length > 0) {
        filterButtons.forEach(button => {
            button.addEventListener('click', function() {
                // 更新按钮激活状态
                filterButtons.forEach(btn => btn.classList.remove('active'));
                this.classList.add('active');
                
                // 设置当前过滤状态
                const buttonText = this.textContent;
                switch (buttonText) {
                    case '全部车辆':
                        currentFilterStatus = '';
                        break;
                    case '可租车辆':
                        currentFilterStatus = 0;
                        break;
                    case '已租车辆':
                        currentFilterStatus = 1;
                        break;
                    case '维护中':
                        currentFilterStatus = 2;
                        break;
                }
                
                // 执行过滤
                performSearch();
            });
        });
    }
}

/**
 * 执行搜索和过滤
 */
function performSearch() {
    const searchInput = document.querySelector('.search-bar .search-input');
    const keyword = searchInput ? searchInput.value : '';
    
    // 构建过滤条件
    const filters = {};
    if (currentFilterStatus !== '') {
        filters.status = currentFilterStatus;
    }
    
    // 执行前端搜索和过滤
    const searchResults = window.SearchUtils ? 
        window.SearchUtils.search(originalVehicleList, keyword, ['brand', 'model', 'licensePlate']) : 
        [];
    
    // 渲染搜索结果
    renderVehicleList(searchResults);
}

// 确保DOM加载完成后执行初始化
function loadScript(url, callback) {
    const script = document.createElement('script');
    script.type = 'text/javascript';
    script.src = url;
    
    script.onload = function() {
        if (callback && typeof(callback) === 'function') {
            callback();
        }
    };
    
    document.head.appendChild(script);
}

function setupInitialization() {
    console.log('准备初始化出借人中心页面');
    
    // 动态加载userVehicles.js文件
    loadScript('../api/userVehicles.js', function() {
        console.log('userVehicles.js加载完成');
        // 初始化出借人中心页面
        initLenderDashboard();
    });
}

// 使用原生方式监听DOM加载完成事件
document.addEventListener('DOMContentLoaded', setupInitialization);

/**
 * 用户令牌认证并获取车辆信息
 */
async function authenticateUserToken() {
    // 首先检测是否有cookie或使用工具函数获取令牌
    let token = null;
    
    // 优先使用AuthTokenManager获取令牌
    if (window.AuthTokenManager && window.AuthTokenManager.getAuthToken) {
        token = window.AuthTokenManager.getAuthToken();
    } else if (window.utils && window.utils.cookie && window.utils.cookie.getAuthToken) {
        // 如果没有AuthTokenManager，则使用utils.cookie工具函数获取令牌
        token = window.utils.cookie.getAuthToken();
    } else {
        // 如果没有工具函数，则使用传统方式从cookie中读取
        try {
            if (document.cookie && document.cookie.trim() !== '') {
                const cookies = document.cookie.split(';');
                for (let i = 0; i < cookies.length; i++) {
                    const cookie = cookies[i].trim();
                    if (cookie.startsWith('auth_token=')) {
                        token = cookie.substring('auth_token='.length);
                        if (token && token.trim() !== '') {
                            break;
                        }
                    }
                }
            }
        } catch (error) {
            console.error('解析cookie时发生错误:', error);
        }
    }
    
    // 如果没有令牌，重定向到登录页
    if (!token) {
        console.log('没有检测到令牌，重定向到登录页');
        window.location.href = './login.html';
        return;
    }
    
    try {
        // 先获取用户信息并显示
        await fetchAndDisplayUserInfo(token);
        
        // 然后向后端发送令牌，查询用户车辆信息
        await fetchUserVehicles(token);
    } catch (error) {
        console.error('认证过程中发生错误:', error);
        alert('认证失败，请重新登录');
        window.location.href = './login.html';
    }
}

/**
 * 获取并显示用户信息
 * @param {string} token - 认证令牌
 */
async function fetchAndDisplayUserInfo(token) {
    console.log('使用令牌获取用户信息:', token);
    
    try {
        // 优先使用认证API获取用户信息（会携带Bearer令牌）
        if (window.api && window.api.auth && window.api.auth.getUserInfo) {
            const result = await window.api.auth.getUserInfo(token);
            if (result && result.success && result.userInfo) {
                console.log('从后端API获取的用户信息:', result.userInfo);
                displayUserInfo(result.userInfo);
                return;
            }
            throw new Error(result?.message || '获取用户信息失败');
        }

        // 兜底：如果没有认证API，则直接通过通用API请求
        if (window.utils && window.utils.api && window.utils.api.get) {
            const headers = { 'Authorization': `Bearer ${token}` };
            const response = await window.utils.api.get('/api/auth/user/info', {}, { headers });
            if (response && response.status === 'success' && response.data) {
                displayUserInfo(response.data);
                return;
            }
            throw new Error(response?.message || '获取用户信息失败');
        }

        // 最后兜底：使用默认数据
        console.warn('API工具不可用，使用默认模拟数据');
        const defaultUserInfo = { username: 'default_user', nickname: '用户', avatar: '' };
        displayUserInfo(defaultUserInfo);
    } catch (error) {
        console.error('获取用户信息失败:', error);
        throw error;
    }
}

/**
 * 查询用户车辆信息
 * @param {string} token - 认证令牌
 * @param {number} page - 当前页码，默认1
 */
async function fetchUserVehicles(token, page = 1) {
    console.log('查询用户车辆信息，页码:', page);
    
    try {
        // 准备请求头，包含Bearer令牌
        const headers = {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
        };
        
        // 发送请求到后端API
        let response;
        
        // 优先使用userVehicles API模块
        if (window.api && window.api.userVehicles && window.api.userVehicles.getUserVehicles) {
            // 保存原始的get函数引用
            const originalGet = window.utils.api.get;
            
            try {
                // 临时重写get函数以注入headers
                window.utils.api.get = function(endpoint, params = {}, options = {}) {
                    return originalGet(endpoint, params, { ...options, headers });
                };
                
                // 调用getUserVehicles函数
                response = await window.api.userVehicles.getUserVehicles({
                    page: page,
                    pageSize: 10
                });
            } finally {
                // 恢复原始的get函数
                window.utils.api.get = originalGet;
            }
        } else {
            // 构建API请求URL，包含分页参数
            const url = `/api/user/vehicles?page=${page}&pageSize=10`;
            
            if (window.utils && window.utils.api && window.utils.api.get) {
                // 优先使用工具函数
                response = await window.utils.api.get(url, {}, { headers });
            } else {
                // 兜底：使用原生fetch
                const fetchResponse = await fetch(url, {
                    method: 'GET',
                    headers: headers
                });
                response = await fetchResponse.json();
            }
        }
        
        console.log('后端返回的车辆信息:', response);
        
        // 处理后端返回的状态码
        if (response && response.code) {
            switch (response.code) {
                case 4004:
                    // 用户未添加任何车辆，不渲染车辆列表
                    console.log('用户未添加任何车辆');
                    originalVehicleList = [];
                    displayNoCarsMessage();
                    break;
                case 4005:
                    // 用户有关联的车辆信息，渲染车辆列表
                    console.log('用户有关联的车辆信息，开始渲染');
                    if (response.data && Array.isArray(response.data)) {
                        // 保存原始车辆数据，用于前端搜索和过滤
                        originalVehicleList = response.data;
                        renderVehicleList(response.data);
                        renderPagination(response.page, response.pageSize, response.total);
                    }
                    break;
                default:
                    console.error('获取车辆信息失败，状态码:', response.code);
                    originalVehicleList = [];
                    displayErrorMessage(response.message || '获取车辆信息失败');
            }
        } else {
            console.error('无效的后端响应');
            originalVehicleList = [];
            displayErrorMessage('获取车辆信息失败，请稍后重试');
        }
    } catch (error) {
        console.error('查询用户车辆信息时发生错误:', error);
        
        // 如果错误是"用户未添加任何车辆"，显示无车辆提示，而不是网络错误
        if (error.message && error.message.includes('用户未添加任何车辆')) {
            console.log('用户未添加任何车辆，显示空状态');
            displayNoCarsMessage();
        } else {
            displayErrorMessage('网络错误，请检查您的网络连接');
        }
    }
}

/**
 * 渲染车辆列表
 * @param {Array} vehicles - 车辆数据数组
 */
function renderVehicleList(vehicles) {
    const carListContainer = document.querySelector('.car-list');
    if (!carListContainer) {
        console.error('未找到车辆列表容器');
        return;
    }
    
    // 清空容器
    carListContainer.innerHTML = '';
    
    // 如果没有车辆数据，显示无数据提示
    if (!vehicles || vehicles.length === 0) {
        displayNoCarsMessage();
        return;
    }
    
    // 遍历车辆数据，创建车辆项
    vehicles.forEach(vehicle => {
        const carItem = document.createElement('div');
        carItem.className = 'car-item';
        
        // 车辆缩略图
        const thumbnail = document.createElement('div');
        thumbnail.className = 'car-thumbnail';
        const carImage = document.createElement('img');
        carImage.src = '../img/car.jpg'; // 使用默认车辆图片
        carImage.alt = `${vehicle.brand || ''} ${vehicle.model || ''}`;
        thumbnail.appendChild(carImage);
        
        // 车辆信息
        const carInfo = document.createElement('div');
        carInfo.className = 'car-info';
        
        // 添加车辆信息项
        carInfo.innerHTML = `
            <div class="info-item">
                <div class="info-label">车辆信息</div>
                <div>${vehicle.brand || ''} ${vehicle.model || ''}</div>
            </div>
            <div class="info-item">
                <div class="info-label">车牌号</div>
                <div>${vehicle.licensePlate || ''}</div>
            </div>
            <div class="info-item">
                <div class="info-label">日租金</div>
                <div>¥${vehicle.dailyRate || '0'}/天</div>
            </div>
            <div class="info-item">
                <div class="info-label">状态</div>
                <div>${getStatusText(vehicle.status)}</div>
            </div>
            <div class="info-item">
                <div class="info-label">租用次数</div>
                <div>${vehicle.rentalCount || '0'}次</div>
            </div>
            <div class="info-item">
                <div class="info-label">可租开始时间</div>
                <div>${formatDate(vehicle.availableStart)}</div>
            </div>
            <div class="info-item">
                <div class="info-label">可租结束时间</div>
                <div>${formatDate(vehicle.availableEnd)}</div>
            </div>
            <div class="info-item">
                <div class="info-label">下次保养时间</div>
                <div>${formatDate(vehicle.nextMaintenance)}</div>
            </div>
        `;
        
        // 车辆操作按钮
        const carActions = document.createElement('div');
        carActions.className = 'car-actions';
        
        const editBtn = document.createElement('button');
        editBtn.className = 'action-btn edit-btn';
        editBtn.textContent = '编辑';
        editBtn.addEventListener('click', () => {
            // 编辑车辆逻辑
            console.log('编辑车辆:', vehicle.instanceId);
            // 将车辆信息转换为JSON字符串并进行URI编码，通过URL参数传递
            const vehicleData = encodeURIComponent(JSON.stringify(vehicle));
            window.location.href = `./edit-vehicle.html?id=${vehicle.instanceId}&vehicleData=${vehicleData}`;
        });
        
        carActions.appendChild(editBtn);
        
        // 组装车辆项
        carItem.appendChild(thumbnail);
        carItem.appendChild(carInfo);
        carItem.appendChild(carActions);
        
        // 添加到车辆列表
        carListContainer.appendChild(carItem);
    });
}

/**
 * 渲染分页控件
 * @param {number} currentPage - 当前页码
 * @param {number} pageSize - 每页数量
 * @param {number} totalCount - 总数量
 */
function renderPagination(currentPage, pageSize, totalCount) {
    const carListContainer = document.querySelector('.car-list');
    if (!carListContainer) return;
    
    // 计算总页数
    const totalPages = Math.ceil(totalCount / pageSize);
    if (totalPages <= 1) return; // 只有一页时不显示分页
    
    // 创建分页容器
    const paginationContainer = document.createElement('div');
    paginationContainer.className = 'pagination';
    
    // 创建页码按钮
    for (let i = 1; i <= totalPages; i++) {
        const pageBtn = document.createElement('button');
        pageBtn.className = `page-btn ${i === currentPage ? 'active' : ''}`;
        pageBtn.textContent = i;
        
        // 添加点击事件
        pageBtn.addEventListener('click', () => {
            if (i !== currentPage) {
                // 重新获取并渲染对应页码的数据
                let token = getAuthToken();
                if (token) {
                    fetchUserVehicles(token, i);
                }
            }
        });
        
        paginationContainer.appendChild(pageBtn);
    }
    
    // 添加到车辆列表容器
    carListContainer.appendChild(paginationContainer);
}

/**
 * 获取认证令牌
 */
function getAuthToken() {
    // 从各种可能的来源获取令牌
    if (window.AuthTokenManager && window.AuthTokenManager.getAuthToken) {
        return window.AuthTokenManager.getAuthToken();
    } else if (window.utils && window.utils.cookie && window.utils.cookie.getAuthToken) {
        return window.utils.cookie.getAuthToken();
    } else {
        try {
            if (document.cookie && document.cookie.trim() !== '') {
                const cookies = document.cookie.split(';');
                for (let i = 0; i < cookies.length; i++) {
                    const cookie = cookies[i].trim();
                    if (cookie.startsWith('auth_token=')) {
                        return cookie.substring('auth_token='.length);
                    }
                }
            }
        } catch (error) {
            console.error('解析cookie时发生错误:', error);
        }
    }
    return null;
}

/**
 * 获取状态显示文本
 * @param {number} status - 车辆状态(0=可租用，1=已租出，2=维护中)
 */
function getStatusText(status) {
    const statusMap = {
        0: '可租用',
        1: '已租出',
        2: '维护中'
    };
    return statusMap[status] || '未知';
}

/**
 * 格式化日期时间显示
 * @param {string|Date} date - 日期对象或日期字符串
 * @returns {string} 格式化后的日期字符串
 */
function formatDate(date) {
    if (!date) return '--';
    try {
        const d = new Date(date);
        const year = d.getFullYear();
        const month = String(d.getMonth() + 1).padStart(2, '0');
        const day = String(d.getDate()).padStart(2, '0');
        return `${year}-${month}-${day}`;
    } catch (error) {
        return date.toString().split('T')[0] || '--';
    }
}



/**
 * 显示用户信息
 * @param {Object} userInfo - 用户信息对象
 */
function displayUserInfo(userInfo) {
    console.log('显示用户信息:', userInfo);
    
    try {
        // 在页面顶部右侧用户区域显示用户信息
        const userSection = document.getElementById('userSection');
        if (userSection) {
            // 清空用户区域
            userSection.innerHTML = '';
            
            // 创建用户信息容器
            const userInfoContainer = document.createElement('div');
            userInfoContainer.className = 'user-info';
            
            // 添加用户头像
            const avatarImg = document.createElement('img');
            avatarImg.src = userInfo.avatar || '../img/user-placeholder.jpg';
            avatarImg.alt = userInfo.nickname || '用户头像';
            avatarImg.className = 'user-avatar';
            
            // 添加用户名
            const usernameSpan = document.createElement('span');
            usernameSpan.className = 'username';
            usernameSpan.textContent = userInfo.nickname || userInfo.username || '用户';
            
            // 将头像和用户名添加到容器
            userInfoContainer.appendChild(avatarImg);
            userInfoContainer.appendChild(usernameSpan);
            
            // 将用户信息容器添加到用户区域
            userSection.appendChild(userInfoContainer);
        }
        
        console.log('用户信息已显示在顶部右侧');
    } catch (error) {
        console.error('显示用户信息时发生错误:', error);
    }
}

/**
 * 显示无车辆提示信息
 */
function displayNoCarsMessage() {
    const carListContainer = document.querySelector('.car-list');
    if (!carListContainer) return;
    
    carListContainer.innerHTML = `
        <div class="no-cars-message">
            <p>暂无车辆数据</p>
            <a href="./add-vehicle.html" style="color: #0066cc; text-decoration: none;">
                立即添加您的第一辆车
            </a>
        </div>
    `;
}

/**
 * 显示错误信息
 * @param {string} message - 错误信息
 */
function displayErrorMessage(message) {
    const carListContainer = document.querySelector('.car-list');
    if (!carListContainer) return;
    
    carListContainer.innerHTML = `
        <div class="no-cars-message">
            <p>${message}</p>
        </div>
    `;
}

/**
 * 添加退出登录事件监听
 */
function addLogoutEventListener() {
    const logoutButton = document.querySelector('.logout-btn');
    if (logoutButton) {
        logoutButton.addEventListener('click', function() {
            handleLogout();
        });
    }
}

/**
 * 退出登录功能
 */
function handleLogout() {
    console.log('执行退出登录');
    
    // 清除令牌
    if (window.AuthTokenManager && window.AuthTokenManager.removeAuthToken) {
        window.AuthTokenManager.removeAuthToken();
    } else if (window.utils && window.utils.cookie && window.utils.cookie.removeAuthToken) {
        window.utils.cookie.removeAuthToken();
    } else {
        // 如果没有工具函数，则手动清除cookie
        document.cookie = 'auth_token=; Max-Age=-99999999; path=/';
    }
    
    // 重定向到登录页
    alert('退出登录成功！');
    window.location.href = './login.html';
}

// 初始化逻辑已移至setupInitialization函数中
// document.addEventListener('DOMContentLoaded', initLenderDashboard);